Tutoriel R Shiny et Leaflet
Xavier Gallagher
6 juillet 2018
Ce document est un tutoriel pour permettre de refaire l’application R Shiny suivante: Taux de Chômage à Montréal Prendre note que le temps de chargement de l’application est long. Ce tutoriel vise à manipuler des données géospatiales avec R, générer une carte interactive web ainsi qu’un explorateur de données interactif.
Installation des packages
Pour installer un package, deux options sont disponibles. La première, allez dans l’onglet packages et sélectionner Install et entrer les noms des packages désirés
Pour accéder aux documents descriptifs des packages, seulement cliquez sur le nom du package en bleu. Le document avec toutes les fonctionnalités apparait.
L’autre façon d’installer des packages est directement au début du script comme l’obligent les applications Shiny. Voici les packages nécessaires pour l’application Shiny.
install.packages("shiny")
install.packages("leaflet")
install.packages("rgdal")
install.packages("RColorBrewer")
install.packages("shinythemes")
install.packages("ggplot2")
install.packages("sp")
install.packages("htmltools")Les Données
Pour réaliser la cartographie, des données du recensement de 2016 ont été utilisées pour générer un fichier où chaque polygone correspond à une Aire de Diffusion. Les Aires de Diffusion sont des divisions du recensement qui compte en moyenne de 400 à 700 personnes. Chaque polygone contient plusieurs attributs intéressants.
Lire un GeoJSON
Avec R, les données géospatiales peuvent facilement être lues avec la library rgdal sous l’ensemble des formats couramment utilisés (shp, xml, geojson, etc.). L’avantage d’un GeoJSON est qu’il n’est formé que d’un seul fichier interne, comparativement au fichier SHP qui en contient plusieurs. Pour les applications web Shiny, le GeoJSON est facilement utilisable et préconisé. Il est important d’utiliser la projection WGS84, car elle est supportée par Leaflet. Autrement, il peut y avoir plusieurs problèmes lors de la création de la carte interactive.
On le lit de la sorte:
library(rgdal) #<- permet d'activer le package rgdal et ses fonctions. Sinon, cocher la case à coté du nom## Loading required package: sp## rgdal: version: 1.3-4, (SVN revision 766)
## Geospatial Data Abstraction Library extensions to R successfully loaded
## Loaded GDAL runtime: GDAL 2.2.3, released 2017/11/20
## Path to GDAL shared files: C:/Users/galx1701/Documents/R/win-library/3.5/rgdal/gdal
## GDAL binary built with GEOS: TRUE
## Loaded PROJ.4 runtime: Rel. 4.9.3, 15 August 2016, [PJ_VERSION: 493]
## Path to PROJ.4 shared files: C:/Users/galx1701/Documents/R/win-library/3.5/rgdal/proj
## Linking to sp version: 1.3-1DataMTL <- readOGR("F:/Tutoriel_R/Tutoriel_R/Montreal/data/MTL_Data.geojson") #<- remplacer les \ habituels par /## OGR data source with driver: GeoJSON
## Source: "F:\Tutoriel_R\Tutoriel_R\Montreal\data\MTL_Data.geojson", layer: "MTL_Data"
## with 3202 features
## It has 21 fieldssummary(DataMTL) #<- permet de voir un appercu de chacun des attributs. ## Object of class SpatialPolygonsDataFrame
## Coordinates:
## min max
## x -73.97640 -73.47607
## y 45.40213 45.70375
## Is projected: FALSE
## proj4string :
## [+proj=longlat +datum=WGS84 +no_defs +ellps=WGS84 +towgs84=0,0,0]
## Data attributes:
## DENSI_POP REVENUTOTA REVENUTO_A REVMEDIANM
## Min. : 0 Min. : 0 Min. : 0 Min. : 0
## 1st Qu.: 4532 1st Qu.:24224 1st Qu.: 30191 1st Qu.: 43072
## Median : 9044 Median :29408 Median : 36794 Median : 52352
## Mean : 10271 Mean :30780 Mean : 42455 Mean : 61315
## 3rd Qu.: 13952 3rd Qu.:35495 3rd Qu.: 45456 3rd Qu.: 67424
## Max. :135547 Max. :87296 Max. :846434 Max. :406528
##
## REVMOYENME VALEURMOYE AUCUNCERTI V27
## Min. : 0 Min. : 0 Min. : 0.00 Min. : 0.00
## 1st Qu.: 52175 1st Qu.: 322379 1st Qu.:10.00 1st Qu.:16.00
## Median : 63811 Median : 404297 Median :16.00 Median :20.00
## Mean : 79354 Mean : 419443 Mean :17.39 Mean :20.48
## 3rd Qu.: 85937 3rd Qu.: 504670 3rd Qu.:24.00 3rd Qu.:25.00
## Max. :1966522 Max. :2707423 Max. :56.00 Max. :45.00
##
## CERTIFICAT AUTOMOBILE AUTOMOBI_A TRANSPORTE
## Min. : 0.00 Min. : 0.00 Min. : 0.000 Min. : 0.00
## 1st Qu.:52.00 1st Qu.:36.00 1st Qu.: 0.000 1st Qu.:24.00
## Median :62.00 Median :51.00 Median : 3.000 Median :34.00
## Mean :61.71 Mean :50.13 Mean : 3.108 Mean :34.16
## 3rd Qu.:72.00 3rd Qu.:65.00 3rd Qu.: 5.000 3rd Qu.:44.00
## Max. :95.00 Max. :97.00 Max. :21.000 Max. :78.00
##
## APIED BICYCLETTE AUTREMOYEN ZTAUXDECH
## Min. : 0.000 Min. : 0.000 Min. : 0.0000 Min. :-1.764420
## 1st Qu.: 3.000 1st Qu.: 0.000 1st Qu.: 0.0000 1st Qu.:-0.672200
## Median : 6.000 Median : 0.000 Median : 0.0000 Median :-0.135680
## Mean : 7.854 Mean : 3.435 Mean : 0.8926 Mean :-0.000001
## 3rd Qu.:10.000 3rd Qu.: 5.000 3rd Qu.: 0.0000 3rd Qu.: 0.554140
## Max. :63.000 Max. :33.000 Max. :15.0000 Max. : 5.900250
##
## V38 ADIDU_1 lat lon
## Min. : 0.000 24660001: 1 Min. :1225508 Min. :7604347
## 1st Qu.: 5.600 24660002: 1 1st Qu.:1239902 1st Qu.:7623907
## Median : 8.350 24660003: 1 Median :1246069 Median :7627308
## Mean : 9.165 24660004: 1 Mean :1245793 Mean :7625948
## 3rd Qu.:12.100 24660005: 1 3rd Qu.:1250884 3rd Qu.:7630364
## Max. :40.000 24660006: 1 Max. :1267923 Max. :7635223
## (Other) :3196
## long
## Min. :7604347
## 1st Qu.:7623907
## Median :7627308
## Mean :7625948
## 3rd Qu.:7630364
## Max. :7635223
## Lorsque des variables sont créées, elles apparaissent dans l’historique de rstudio avec toutes les informations descriptives. 
Carte intéractive Leaflet.
Pour générer la carte intéractive, nous utilisons le package Leaflet. Nous allons bâtir étape par étape la carte, les palettes de couleurs, les étiquettes intéractives, le sélectionneur de couche ainsi que la légende.
Création de la carte
Tout d’abord, nous allons commencer par afficher les polygones du GeoJSON sur un fond de carte. Nous mettons le GeoJSON dans l’objet DataMTL. Ensuite, nous générons la carte dans l’objet m. La commande leaflet(DataMTL) spécifie que la donnée géospatiale à afficher est le GeoJSON. Dans le cas de %>%, il s’agit d’un opérateur de piping pipe operator. Cet opérateur mentionne que la fonction addProviderTiles() est générée, puis les polygones de leaflet(DataUSA) sont ajoutés par dessus. addProviderTiles() contient les arguements nécessaires pour contrôler le fond de carte. Plusieurs fonds de carte sont disponibles. L’aide contient toutes les possibilités de fond de carte ou sur addProviderTiles. L’objet m contient maintenant l’information sur le fichier géospatial à utiliser. La dernière étape est d’afficher les polygones sur la carte et son basemap. La fonction addPolygons() stipule que les polygones viennent de la donnée de DataMTL et sont affichés sur la carte m. Le résultat de ces lignes apparait dans l’onglet viewer de RStudio.
DataMTL <- readOGR("F:/Tutoriel_R/Tutoriel_R/Montreal/data/MTL_Data.geojson")
m <- leaflet(DataMTL) %>%
addProviderTiles(providers$OpenStreetMap.Mapnik, options= providerTileOptions(opacity = 0.99))
m %>% addPolygons(data = DataMTL)
Création de la palette de couleur et symbologie
La mise en place d’une palette de couleur d’une variable continue demande une étape de plus. Il faut générer une palette de couleur propre à la variable choisie. Les variables sont les différents attributs contenus dans les colonnes du GeoJSON. Dans cet exemple, la variable est V38 représente le taux de chômage.
Il faut définir les intervalles voulus pour générer les classes. Par la suite, il faut sélectionner la palette de couleur à notre goût. La librairie RColorBerwer permet de générer une fonction qui prend en compte les intervalles préalablement générés. Une fois la palette de couleur définie, il est alors possible d’afficher les polygones avec la nouvelle symbologie. Pour ce faire, nous utilisons plusieurs arguments de la fonction addPolygons. Le plus important dans notre cas est fillColor.
DataMTL <- readOGR("F:/Tutoriel_R/Tutoriel_R/Montreal/data/MTL_Data.GeoJSON")
binV38<- c(0, 5, 10, 15, 20, 25, 30, 35, 40) # <- valeur des intervals en %
palV38 <- colorBin("YlOrRd", domain = DataMTL$binV38, bins = binV38) #<- choix de la palette de couleur
m <- leaflet(DataMTL) %>%
addProviderTiles(providers$OpenStreetMap.Mapnik, options= providerTileOptions(opacity = 0.99))
m %>% addPolygons(data = DataMTL,
stroke = TRUE,
fillColor = ~palV38(V38), #<- spécifie la fonciton palette appliquée sur la variable V38
weight = 2,
opacity = 1,
color = "grey", #<- contour des polygones
dashArray= "3",
fillOpacity = 0.7,
highlight = highlightOptions( #<- argument permettantun highlight au passage du curseur de la souris.
weight = 5,
color = "#666",
dashArray = "",
fillOpacity = 0.7,
bringToFront = TRUE))
Une fois les couleurs définies, il faut afficher la légende. Il suffit d’ajouter la fonciton addLegend avec l’opérateur %>% et de spécifier la palette de couleur utilisée, le titre ainsi que la variable choisie.
DataMTL <- readOGR("F:/Tutoriel_R/Tutoriel_R/Montreal/data/MTL_Data.GeoJSON")
binV38<- c(0, 5, 10, 15, 20, 25, 30, 35, 40) # <- valeur des intervals en %
palV38 <- colorBin("YlOrRd", domain = DataMTL$binV38, bins = binV38) #<- choix de la palette de couleur
m <- leaflet(DataMTL) %>%
addProviderTiles(providers$OpenStreetMap.Mapnik, options= providerTileOptions(opacity = 0.99))
m %>% addPolygons(data = DataMTL,
stroke = TRUE,
fillColor = ~palV38(V38), #<- spécifie la fonciton palette appliquée sur la variable V38
weight = 2,
opacity = 1,
color = "grey", #<- contour des polygones
dashArray= "3",
fillOpacity = 0.7,
highlight = highlightOptions( #<- argument permettantun highlight au passage du curseur de la souris.
weight = 5,
color = "#666",
dashArray = "",
fillOpacity = 0.7,
bringToFront = TRUE))%>%
addLegend(pal = palV38,
values = DataMTL$binV38,
opacity = 0.7,
title = "Taux de Chômage",
position = "bottomleft")
## Ajout des étiquettes interactives
Maintenant, nous allons afficher l’étiquette contenant la valeur de chaque polygone. Il faut créer un objet contenant la fonction sprintf qui permet de formater des lignes de caractères. Dans sprintf, le premier argument doit contenir la ligne de cratères. %s permet de mettre en gras la valeur retournée par %s. Dans notre cas, %s retourne la valeur de V38. Ensuite, on applique avec lapply le package htmltools pour générer le overring*.
Il ne reste qu’a ajouté l’argument labels et lablesOptions dans addPolygons et le tour est joué.
DataMTL <- readOGR("F:/Tutoriel_R/Tutoriel_R/Montreal/data/MTL_Data.GeoJSON")
binV38<- c(0, 5, 10, 15, 20, 25, 30, 35, 40) # <- valeur des intervals en %
palV38 <- colorBin("YlOrRd", domain = DataMTL$binV38, bins = binV38) #<- choix de la palette de couleur
labelV38 <- sprintf(
" Taux de Chômage: <strong>%s</strong> ",
DataMTL$V38
) %>% lapply(htmltools::HTML)
m <- leaflet(DataMTL) %>%
addProviderTiles(providers$OpenStreetMap.Mapnik, options= providerTileOptions(opacity = 0.99))
m %>% addPolygons(data = DataMTL,
group = "Chomage",
stroke = TRUE,
fillColor = ~palV38(V38),
weight = 2,
opacity = 1,
color = "grey",
dashArray= "3",
fillOpacity = 0.7,
highlight = highlightOptions(
weight = 5,
color = "#666",
dashArray = "",
fillOpacity = 0.7,
bringToFront = TRUE),
label = labelV38,
labelOptions = labelOptions(
style = list("font-weight" = "normal", padding = "3px 8px"),
textsize = "15px",
direction = "auto"))%>%
addLegend(pal = palV38,
values = DataMTL$binV38,
opacity = 0.7,
title = "Taux de Chômage",
position = "bottomleft")
#Application Shiny
## Création d’une app Shiny.
Pour commencer à faire l’app Shiny, il faut ouvrir un nouveau projet Shiny. Allez dans file -> New File -> Shiny Web App. Une fois sélectionné, entrez un nom d’app et un répertoire de travail. Cocher single file:
Maintenant que nous avons une cartographie qui fonctionne toute seule, nous pouvons l’ajouter à une application Shiny. La portion d’installation des packages se retrouve au-dessus du ui. Il est important de mentionner tous les packages nécessaires à la cartographie. Dans le ui, nous retrouvons les titres et le output de la fonction server qui est affiché dans la fenêtre. La portion server contient la création de la carte. La portion de création de la carte leaflet précédente nécessite quelques petites modifications pour être utilisée dans une app Shiny. Le nom de l’objet de la carte doit apparaitre dans la fonction leafletOutput contenue dans le UI. Donc la partie d’installation des librairies, l’importation des données ainsi que le ui ressemble à cela:
library(shiny)
library(leaflet)
library(rgdal)
library(RColorBrewer)
library(shinythemes)
library(ggplot2)
library(sp)
DataMTL <- readOGR("F:/Tutoriel_R/Tutoriel_R/Montreal/data/MTL_Data.GeoJSON")
ui <- fluidPage(
titlePanel("Taux de Chômage à Montréal"), #<- titre principal de l'APP
tabsetPanel( #<- tabsetPanel permet de générer plusieurs onglets.
tabPanel("Carte par Aire de Diffusion", leafletOutput("DataMTL", height = 600, width = 1300)) #<- premier onglet.
),
theme = shinytheme("slate") #<- theme automatique shiny noir
)
# ===============================================================
# Section de mise en place des bins et labels
binV38<- c(0, 5, 10, 15, 20, 25, 30, 35, 40) # <- valeur des intervals en %
palV38 <- colorBin("YlOrRd", domain = DataMTL$binV38, bins = binV38) #<- choix de la palette de couleur
labelV38 <- sprintf(
" Taux de Chômage: <strong>%s</strong> ",
DataMTL$V38
) %>% lapply(htmltools::HTML)
#=================================================================
server <- function(input, output, session) {
output$DataMTL <- renderLeaflet({
leaflet()%>%
addProviderTiles(providers$OpenStreetMap.HOT, options= providerTileOptions(opacity = 0.99)) %>%
addPolygons(data = DataMTL,
group = "Chomage",
stroke = TRUE,
fillColor = ~palV38(V38),
weight = 2,
opacity = 1,
color = "grey",
dashArray= "3",
fillOpacity = 0.7,
highlight = highlightOptions(
weight = 5,
color = "#666",
dashArray = "",
fillOpacity = 0.7,
bringToFront = TRUE),
label = labelV38,
labelOptions = labelOptions(
style = list("font-weight" = "normal", padding = "3px 8px"),
textsize = "15px",
direction = "auto")) %>%
addLegend(pal = palV38,
values = DataMTL$binV38,
opacity = 0.7,
title = "Taux de Chômage",
position = "bottomleft")
})
}
shinyApp(ui, server)Ajout de couche
Pour ajouter une deuxième couche et un sélecteur de couche, il faut ajouter quelques lignes de codes dans le addLegend. Ces lignes permettent de sélectionner un des output générés dans la portion server du code. Tout d’abord, il faut créer une nouvelle palette de couleur ainsi que des nouvelles étiquettes. Nous allons ajouter la variable REVMEDIANM qui correspond au revenu médian par AD.
Dans ce cas-ci, la nouvelle palette de couleur pour REVMEDIANM ainsi que les étiquettes ressemblent à cela:
binRevMed <- c(0, 50816, 101632, 152448, 203264, 254080, 304896, 355712, 406528)
palRevMed <- colorBin("YlOrRd", domain = DataMTL$REVMEDIANM, bins = binRevMed)
labelRevMed <- sprintf(
" Revenu Médian: <strong>%s</strong> ",
DataMTL$REVMEDIANM
) %>% lapply(htmltools::HTML)Pour ce qui est de la portion, server, il faut copier-coller la fonction addPolygons déjà présente et modifier les arguments suivants: group, fillColor et label. Cette nouvelle section addPolygons est ajoutée à la suite de la précédente avec l’opérateur %>%. La création des polygones ressemble à cela:
server <- function(input, output, session) {
output$DataMTL <- renderLeaflet({
leaflet()%>%
addProviderTiles(providers$OpenStreetMap.HOT, options= providerTileOptions(opacity = 0.99)) %>%
addPolygons(data = DataMTL,
group = "Chomage",
stroke = TRUE,
fillColor = ~palV38(V38),
weight = 2,
opacity = 1,
color = "grey",
dashArray= "3",
fillOpacity = 0.7,
highlight = highlightOptions(
weight = 5,
color = "#666",
dashArray = "",
fillOpacity = 0.7,
bringToFront = TRUE),
label = labelV38,
labelOptions = labelOptions(
style = list("font-weight" = "normal", padding = "3px 8px"),
textsize = "15px",
direction = "auto")) %>%
addPolygons(data = DataMTL,
group = "RevMedian",
stroke = TRUE,
fillColor = ~palRevMed(REVMEDIANM),
weight = 2,
opacity = 1,
color = "grey",
dashArray= "3",
fillOpacity = 0.7,
highlight = highlightOptions(
weight = 5,
color = "#666",
dashArray = "",
fillOpacity = 0.7,
bringToFront = TRUE),
label = labelRevMed,
labelOptions = labelOptions(
style = list("font-weight" = "normal", padding = "3px 8px"),
textsize = "15px",
direction = "auto"))
}) #<- ferme le renderLeafletLeaflet offre la fonction addLayersControl qui permet de générer un sélectionneur de couches . Cette fonction génère un input qui sera utilisé plus loin. La fonction addLayersControl est ajoutée à la suite du dernier addPolygons, toujours avec l’opérateur %>%.
L’argument *group présent dans la fonction addPolygons permet d’activer certaines couches dès l’ouverture de l’app. Il faut spécifier quelle couche n’apparait pas. La fonction hideGroup est utilisée. Les lignes de code suivantes sont ajoutées à la suite du dernier addPolygons.
addPolygons() %>%
addLayersControl(baseGroups = c("OSM (default)"),
overlayGroups = c("Chomage", "RevMedian"),
options = layersControlOptions(collapsed = FALSE)) %>%
hideGroup("RevMedian")
}) <- fermeture du renderLeaflet(). Par la suite, il faut être en mesure de retenir le clic de souris de l’utilisateur sur le sélectionneur de couches. Pour se faire, Shiny offre la fonction observeEvent qui permet d’afficher la couche qui correspond au choix de l’utilisateur, mais également la légende. Cette fonction est ajoutée dans la section server indépendamment de la section renderLeaflet.
observeEvent(input$DataMTL_groups,{
DataMTL <- leafletProxy("DataMTL") %>% clearControls()
if (input$DataMTL_groups == 'Chomage')
{DataMTL <- DataMTL %>% addLegend(pal = palV38, values = DataMTL$V38, opacity = 0.7, title = "Taux de Chômage",
position = "bottomleft")}
else if (input$DataMTL_groups == 'RevMedian')
{DataMTL <- DataMTL %>% addLegend(pal = palRevMed, values = DataMTL$REVMEDIANM,
opacity = 0.7, title = "Revenu Médian",
position = "bottomleft")}
})Nous avons maintenant une application cartographique avec un sélectionneur de couches et des légendes adaptatives. Pour ajouter d’autres couches, il suffit de répéter les étapes précédentes et le tour est joué.
Explorateur de données.
Il est possible d’ajouter des onglets dans une app Shiny. Pour cet exemple, nous allons ajouter un explorateur de données. Deux étapes sont nécessaires. Premièrement,il faut ajouter transformer les données du GeoJSON en dataframe et deuxièmement, il faut modifier le ui . Finalement, la fonction d’exploration est ajoutée dans la portion server.
Pour transformer le GeoJSON en dataframe, il ne suffit de prendre la variable DataMTL et la transformer en dataframe. DataMTL est la variable contenant les informations géospatiales permettant de générer la carte alors que DataExplore permet de faciliter l’affichage des attributs. L’importation des données ressemble à ceci:
DataMTL <- readOGR("data/MTL_Data.geojson")
DataExplore <-as.data.frame(DataMTL)Par la suite, nous devons modifier le ui. Nous ajoutons un tabPanel
DataMTL <- readOGR("F:/Tutoriel_R/Tutoriel_R/Montreal/data/MTL_Data.GeoJSON")
DataExplore <-as.data.frame(DataMTL)
ui <- fluidPage(
titlePanel("Taux de Chômage à Montréal"), #<- titre principal de l'APP
tabsetPanel( #<- tabsetPanel permet de générer plusieurs onglets.
tabPanel("Carte par Aire de Diffusion", leafletOutput("DataMTL", height = 600, width = 1300)),#<- premier onglet.
tabPanel("Explorateur de données", dataTableOutput("DataExplore")) #<- permet de créer un nouvel onglet.
),
theme = shinytheme("slate") #<- theme automatique shiny noir
)Une fois le ui modifié, nous ajoutons la portion dans le server. Cette portion s’ajoute à la suite de la section qui génère la carte.
output$DataExplore <- renderDataTable(
DataExplore,
options = list(
pageLength = 5)Nous avons maintenant un explorateur de données. Il est possible de faire des recherches par nom, trier de différentes façons et modifier le nombre de lignes visibles.
Explorateur Graphique
Dans cette portion, nous allons ajouter un graphique interactif permettant à l’usager de sélectionner certains attributs et de générer un scatterplot automatiquement. Nous allons utiliser la variable DataExplore, car son format facilite la création d’un graphique. Il faut encore modifier le ui et ajouter deux blocs de codes au server.
Tout d’abord, il faut ajouter un nouvel onglet au ui. Dans cet onglet, nous voulons un menu situé sur le coté gauche de la page, contenant deux listes déroulantes. Ces listes comporteront toutes les variables que l’utilisateur pourra sélectionner. Nous allons utilisé, dans la portion tabPanel la fonction sidebarLayout pour générer le menu, sidebarPanel pour permettre l’utilisation du menu ainsi que deux selectInput pour sélectionner les variables x et y. Pour la selectInput, il ne suffit que de lister l’ensemble des attributs désirés. Les choix ne sont pas obligatoirement les mêmes pour les deux variables.
La section UI ressemble à ceci:
ui <- fluidPage(
titlePanel("Taux de Chômage à Montréal"), #<- titre principal de l'APP
tabsetPanel(
tabPanel("Carte par Aire de Diffusion", leafletOutput("DataMTL", height = 600, width = 1300)),
tabPanel("Explorateur de données", dataTableOutput("DataExplore")),
tabPanel("Explorateur Graphique",
sidebarLayout(
sidebarPanel(
selectInput('xcol', 'variable x', choices = c("DENSI_POP", "REVENUTOTA", "REVENUTO_A", "REVMEDIANM", "REVMOYENME",
"VALEURMOYE", "AUCUNCERTI", "V38", "ZTAUXDECH", "APIED", "BICYCLETTE", "AUTOMOBILE")),
selectInput('ycol', 'variable y', choices = c("DENSI_POP", "REVENUTOTA", "REVENUTO_A", "REVMEDIANM", "REVMOYENME",
"VALEURMOYE", "AUCUNCERTI", "V38", "ZTAUXDECH", "APIED", "BICYCLETTE", "AUTOMOBILE"))
),
mainPanel(
plotOutput("plotMTL")
)
)
)
),
theme = shinytheme("slate")
)Il ne reste qu’à ajouter la création du graphique dans la portion server. Il faut tout d’abord créer la fonction permettant de garder en mémoire les choix de l’utilisateur, xcol et ycol. Pour ce faire, une nouvelle variable, selectedData est créée à la suite de l’explorateur de données.
selectedData <- reactive({
DataExplore[, c(input$xcol, input$ycol)]Par la suite, il faut ajouter la variable qui contiendra le graphique. plotMTL. Nous allons utiliser le package ggplot2 pour réaliser le graphique. Pour bien résumer les différentes options et syntaxes de ggplot2, je vous conseille d’aller voir le document résumé Cheat Sheet. L’important est que les variables utilisées dans la création du graphique sont celles contenues dans la variable selectedData. De plus, la section aes_string() permet de contrôler les variables, mais également les couleurs. En utilisant color = input$ycol la palette de couleur s’adaptera à la valeur de la variable sélectionnée en y. De plus, scale_color_distiller(palette = “RdPu”) permet d’utiliser une palette de couleur déjà créée.
output$plotMTL <- renderPlot({
p <- ggplot(selectedData(), aes_string(x = input$xcol, y=input$ycol, color= input$ycol)) +
geom_point() + scale_color_distiller(palette = "RdPu")
print(p)
}) Le code est maintenat complet.
Code Compet.
# Importation des differents packages necessaire pour la realisation il est important de noter
# qu'ils doivent etre deja telecharge sur RStudio.
list.of.packages <- c("shiny", "rgdal","leaflet", "RColorBrewer", "shinythemes", "ggplot2", "sp")
new.packages <- list.of.packages[!(list.of.packages %in% installed.packages()[,"Package"])]
if(length(new.packages) > 0) {install.packages(new.packages)}
lapply(list.of.packages, require, character.only=T)
library(shiny)
library(leaflet)
library(rgdal)
library(RColorBrewer)
library(shinythemes)
library(ggplot2)
library(sp)
#Les donnes sont situer dans deux fichiers differents. Les donnes de crimes depuis 1980, qui sont utiliser pour
# la mise en place de graphiques interactif est en fichier CSV. Dans le cas des donnees cartographiques, elles sont
# En Fichier GeoJSON. Ce format contient un seul dossier, se qui facilite l'importation et la manipulation.
DataMTL <- readOGR("data/MTL_Data.geojson")
DataExplore <-as.data.frame(DataMTL)
# Debut du fichier ui, soit le user interface. Il contient les details de la structure de l'APP
# Dans cette section, nous devons preciser quels contenus se retrouverons dans les differentes pages.
# L'utilisation de tabsetPanel, permet d'utiliser differents onglets.
ui <- fluidPage(
titlePanel("Taux de Chômage à Montréal"), #<- titre principal de l'APP
tabsetPanel(
tabPanel("Carte par Aire de Diffusion", leafletOutput("DataMTL", height = 600, width = 1300)),
tabPanel("Explorateur de données", dataTableOutput("DataExplore")),
tabPanel("Explorateur Graphique",
sidebarLayout(
sidebarPanel(
selectInput('xcol', 'variable x', choices = c("DENSI_POP", "REVENUTOTA", "REVENUTO_A",
"REVMEDIANM", "REVMOYENME", "VALEURMOYE",
"AUCUNCERTI", "V38", "ZTAUXDECH", "APIED",
"BICYCLETTE", "AUTOMOBILE")),
selectInput('ycol', 'variable y', choices = c("DENSI_POP", "REVENUTOTA", "REVENUTO_A",
"REVMEDIANM", "REVMOYENME", "VALEURMOYE",
"AUCUNCERTI", "V38", "ZTAUXDECH", "APIED",
"BICYCLETTE", "AUTOMOBILE"))
),
# Show a plot of the generated distribution
mainPanel(
plotOutput("plotMTL")
)
)
)
),
theme = shinytheme("slate")
)
binV38<- c(0, 5, 10, 15, 20, 25, 30, 35, 40) # <- valeur des intervals en %
palV38 <- colorBin("YlOrRd", domain = DataMTL$binV38, bins = binV38) #<- choix de la palette de couleur
labelV38 <- sprintf(
" Taux de Chômage: <strong>%s</strong> ",
DataMTL$V38
) %>% lapply(htmltools::HTML)
binRevMed <- c(0, 50816, 101632, 152448, 203264, 254080, 304896, 355712, 406528)
palRevMed <- colorBin("YlOrRd", domain = DataMTL$REVMEDIANM, bins = binRevMed)
labelRevMed <- sprintf(
" Revenu Médian: <strong>%s</strong> ",
DataMTL$REVMEDIANM
) %>% lapply(htmltools::HTML)
server <- function(input, output, session) {
output$DataMTL <- renderLeaflet({
leaflet()%>%
addProviderTiles(providers$OpenStreetMap.HOT, options= providerTileOptions(opacity = 0.99)) %>%
addPolygons(data = DataMTL,
group = "Chomage",
stroke = TRUE,
fillColor = ~palV38(V38),
weight = 2,
opacity = 1,
color = "grey",
dashArray= "3",
fillOpacity = 0.7,
highlight = highlightOptions(
weight = 5,
color = "#666",
dashArray = "",
fillOpacity = 0.7,
bringToFront = TRUE),
label = labelV38,
labelOptions = labelOptions(
style = list("font-weight" = "normal", padding = "3px 8px"),
textsize = "15px",
direction = "auto")) %>%
addPolygons(data = DataMTL,
group = "RevMedian",
stroke = TRUE,
fillColor = ~palRevMed(REVMEDIANM),
weight = 2,
opacity = 1,
color = "grey",
dashArray= "3",
fillOpacity = 0.7,
highlight = highlightOptions(
weight = 5,
color = "#666",
dashArray = "",
fillOpacity = 0.7,
bringToFront = TRUE),
label = labelRevMed,
labelOptions = labelOptions(
style = list("font-weight" = "normal", padding = "3px 8px"),
textsize = "15px",
direction = "auto")) %>%
addLayersControl(baseGroups = c("OSM (default)"),
overlayGroups = c("Chomage", "RevMedian"),
options = layersControlOptions(collapsed = FALSE)) %>%
hideGroup("RevMedian")
})
# creation Event Map MTL
observeEvent(input$DataMTL_groups,{
DataMTL <- leafletProxy("DataMTL") %>% clearControls()
if (input$DataMTL_groups == 'Chomage')
{DataMTL <- DataMTL %>% addLegend(pal = palV38, values = DataMTL$V38, opacity = 0.7, title = "Taux de Chômage",
position = "bottomleft")}
else if (input$DataMTL_groups == 'RevMedian')
{DataMTL <- DataMTL %>% addLegend(pal = palRevMed, values = DataMTL$REVMEDIANM,
opacity = 0.7, title = "Revenu Médian",
position = "bottomleft")}
})
output$DataExplore <- renderDataTable(
DataExplore,
options = list(
pageLength = 5)
)
selectedData <- reactive({
DataExplore[, c(input$xcol, input$ycol)]
})
output$plotMTL <- renderPlot({
p <- ggplot(selectedData(), aes_string(x = input$xcol, y=input$ycol, color= input$ycol)) +
geom_point() + scale_color_distiller(palette = "RdPu")
print(p)
})
}
shinyApp(ui, server)